const app = getApp();

const roleDistribution = {
  5: { red: ['莫甘娜', '刺客'], blue: ['梅林', '忠臣', '派西维尔'] },
  6: { red: ['莫甘娜', '刺客'], blue: ['梅林', '派西维尔', '忠臣x2'] },
  7: { red: ['莫甘娜', '刺客', '奥伯伦'], blue: ['梅林', '派西维尔', '忠臣x2'] },
  8: { red: ['莫甘娜', '刺客', '爪牙'], blue: ['梅林', '派西维尔', '忠臣x3'] },
  9: { red: ['莫德雷德', '莫甘娜', '刺客'], blue: ['梅林', '派西维尔', '忠臣x3'] },
  10: { red: ['莫德雷德', '莫甘娜', '刺客', '奥伯伦'], blue: ['梅林', '派西维尔', '忠臣x4'] }
};

Page({
  data: {
    roomCapacityOptions: [5, 6, 7, 8, 9, 10],  // 可选人数
    selectedCapacity: 5,  // 默认人数
    waitingUsers: Array(4).fill({}),  // 房主外默认4个空位
    hostAvatarUrl: 'cloud://avalon-cloud-1gg01hi5d0e8cec0.6176-avalon-cloud-1gg01hi5d0e8cec0-1330536532/images/hostAvatar.png',  // 默认房主头像
    hostNickname: '房主',  // 默认房主昵称
    roomId: '',
    ownerOpenid: '',
    userList:[],        //玩家列表
    currentUserCount:1,    //当前玩家人数
    useropenid:'',
    redTeamMembers: '',
    blueTeamMembers: '',
    isGameStartDisabled: true,
    hasNavigated: false
  },
  

  onLoad(options) {
    console.log(options)
    const { roomId, ownerOpenid, selectedCapacity } = options;  // 接收传递过来的选定人数
    this.setData({
      ownerOpenid,
      roomId,
      selectedCapacity: selectedCapacity || 5,  // 使用传递过来的人数，默认5人
      waitingUsers: Array(selectedCapacity - 1).fill({})  // 根据选定人数生成等待用户模块
    });
    //this.getRoomInfo(roomId); // 根据房间ID获取房间信息

    this.createopenid();

    this.updateTeamMembers(selectedCapacity);  // 初始化时更新红蓝阵营信息

    const storedUserInfo = wx.getStorageSync('userInfo') || app.globalData.userInfo;
    if (storedUserInfo) {
      this.setData({
        hostAvatarUrl: storedUserInfo.avatarUrl,
        hostNickname: storedUserInfo.nickName
      });
    }

    //定时更新数据库
    this.startRoomInfoUpdate();

    console.log("尝试设置监听，房间ID:", this.data.roomId);
this.setupGameListener(this.data.roomId); // 确保房间ID正确
    //以便所有玩家跟随房主跳转至main
    this.setupGameListener(this.data.roomId);
    
  },

  //暂时不需要，因为调用join_room函数已经实现了相应功能(onload处)
  //10.24更新 已实现，云函数名为getroominfo
  getRoomInfo(roomId) {
    // 这里可以调用云函数获取房间信息
  },

// 选择人数变化时的处理函数
onRoomCapacityChange: function(e) {
  const selected = this.data.roomCapacityOptions[e.detail.value];
  this.setData({
    selectedCapacity: selected
  });
  // 可以在这里将选择的人数传递到其他页面
},

// 跳转到用户信息页面
navigateToUserInfo: function() {
  const roomId = this.data.roomId; 
  const Openid = this.data.useropenid; 
  wx.navigateTo({
    url: `/pages/infoSet/infoSet?roomId=${roomId}&openid=${Openid}` // 新页面的路径
  });
}, 
// 跳转到人数选择页面
navigateToNumset: function() {
  wx.navigateTo({
    url: '/pages/numSet/numSet' // 新页面的路径
  });
}, 

// 退出房间确认框
exitRoom: function() {
  wx.showModal({
    title: '提示',
    content: '确定离开房间？',
    confirmText: '确定',         // 确定按钮的文字
    cancelText: '取消',          // 取消按钮的文字
    confirmColor: '#FF4D4D',     // 确定按钮文字的颜色，红色
    cancelColor: '#999999',      // 取消按钮文字的颜色，灰色
    success: function(res) {
      if (res.confirm) {
        console.log('用户点击确定');
        // 在此处可以编写离开房间的逻辑，比如跳转到首页
        wx.navigateBack(); // 返回上一页
      } else if (res.cancel) {
        console.log('用户点击取消');
        // 用户取消操作，不做任何处理
      }
    }
  });
},
  /**
   * 生命周期函数--监听页面加载
   */
  onRoomCapacitySelect: function(e) {
    const selectedIndex = e.detail.value;  // 获取选中的 index
    const selectedCapacity = this.data.roomCapacityOptions[selectedIndex];  // 根据 index 获取选中的人数

    // 更新选中人数和等待用户模块
    this.setData({
      selectedCapacity: selectedCapacity,
      waitingUsers: Array(selectedCapacity - 1).fill({})  // 减去房主
    });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {
    setTimeout(() => {  
      const openid = this.data.useropenid;  
      console.log('room.js的roomId,openid:', this.data.roomId,openid);  
        
      // 调用云函数以更新数据库（表示新玩家加入）  
      wx.cloud.callFunction({  
        name: 'join_room',  
        data: {  
          roomId: this.data.roomId,  
          userOpenid: openid  
        },  
        success: res => {  
          const { message, currentUserCount, selectedCapacity, userList } = res.result;  
    
          if (message === '成功加入房间') {  
            console.log('成功加入房间');  
            console.log('当前用户数量:', currentUserCount);  
            console.log('房间容量:', selectedCapacity);  
            console.log('用户列表:', userList);  
          }
    
            // 更新页面数据  
            this.setData({  
              currentUserCount: currentUserCount,  
              userList: userList,  
              selectedCapacity: selectedCapacity,  
              waitingUsers: Array(selectedCapacity - currentUserCount).fill({}),
              isGameStartDisabled: (currentUserCount<selectedCapacity)
            });    
        },  
        fail: err => {  
          console.log('Cloud function call failed');  
        }  
      });  
    }, 3000); // 延迟1000毫秒（1秒）后执行 
  },

  /**
   * 生命周期函数--监听页面显示
   */
  // 页面显示时检查用户信息
  onShow() {
    //更新当前页面数据（从数据库）
    this.updateRoomInfo();
    //以便所有玩家跟随房主跳转至main
    this.setupGameListener(this.data.roomId);
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {
    this.stopRoomInfoUpdate();
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    
    this.stopRoomInfoUpdate();
    // 更新阵营角色分布
    this.updateTeamMembers(selectedCapacity);
  },

  updateTeamMembers: function(selectedCapacity) {
    const roles = roleDistribution[selectedCapacity] || { red: [], blue: [] };  // 根据人数获取角色分布

    const redTeamText = roles.red.join(', ');  // 将红方角色数组转为字符串
    const blueTeamText = roles.blue.join(', ');  // 将蓝方角色数组转为字符串

    // 更新红蓝阵营角色显示
    this.setData({
      redTeamMembers: redTeamText,
      blueTeamMembers: blueTeamText
    });
  },

  exitRoom: function() {
    wx.showModal({
      title: '提示',
      content: '确定离开房间？',
      confirmText: '确定',
      cancelText: '取消',
      confirmColor: '#FF4D4D',
      cancelColor: '#999999',
      success: function(res) {
        if (res.confirm) {
          wx.switchTab({  // 使用 wx.switchTab 跳转到 tabBar 页面
            url: '/pages/index/index'  // 确保这里的路径与 app.json 中的 tabBar 路径一致
          });
        }
      }
    });
  },

  navigateToRules: function() {
    wx.navigateTo({
      url: '/pages/gameTutorial/gameTutorial'  // 修改为要跳转的页面路径
    });
  },

  async createopenid() {
    try {
      // 第一步：获取用户的openid
      const openid = await this.getOpenid();

      // 
      this.setData({ useropenid:openid });

    } catch (error) {
      console.log('获取openid失败');
    }
  },
  //获得被邀请用户的openid
  getOpenid() {
    return new Promise((resolve, reject) => {
      wx.cloud.callFunction({
        name: 'get_openid', // 调用获取openid的云函数
        success: res => {
          console.log('获取到的openid:', res.result.openid);
          this.setData({ openid: res.result.openid });
          resolve(res.result.openid); // 成功获取到openid
        },
        fail: err => {
          console.error('获取openid失败', err);
          reject(err); // 获取失败时拒绝Promise
        }
      });
    });
  },

  updateRoomInfo: function() {  
    wx.cloud.callFunction({  
      name: 'getroominfo',  
      data: {  
        roomId: this.data.roomId  
      },  
      success: res => {  
        if (res.result.success) {  
          const rooms = res.result.data;  
          const firstRoom = rooms[0];  
          this.setData({  
            currentUserCount: firstRoom.currentUserCount,  
            selectedCapacity: firstRoom.selectedCapacity,  
            ownerOpenid: firstRoom.ownerOpenid,  
            userList: firstRoom.userList,
            waitingUsers: Array(firstRoom.selectedCapacity - firstRoom.currentUserCount).fill({}),
            isGameStartDisabled: firstRoom.currentUserCount < firstRoom.selectedCapacity // 根据当前人数更新按钮状态
          });  
          console.log('Update info success',firstRoom.userList);  
        }  
      },  
      fail: err => {  
        console.error('Cloud function call failed:', err);  
      }  
    });  
  },

  //如名字所示，为了实现联机同步，需要定时更新房间情况
  startRoomInfoUpdate: function() {  
    // 保存定时器的ID，以便之后可以清除它  
    this.roomInfoUpdateInterval = setInterval(() => {  
      this.updateRoomInfo();  
    }, 10000); // 6000毫秒 
  },  
  stopRoomInfoUpdate: function() {  
    // 清除定时器  
    clearInterval(this.roomInfoUpdateInterval);  
  },  

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage(res){
    //判断触发的方式是否为按钮
    if(res.from=="button"){
      //参数
      console.log('用户点击了分享按钮'); 
      const roomId = this.data.roomId; 
      const ownerOpenid = this.data.ownerOpenid; 
      const selectedCapacity=this.data.selectedCapacity;
      // 构造分享链接（注意：这里的路径和参数应该与您的小程序页面路由相匹配）  
      const shareUrl = `/pages/room/room?roomId=${roomId}&ownerOpenid=${ownerOpenid}&selectedCapacity=${selectedCapacity}`;  
      console.log(shareUrl);
      return{
        title:"加入我的房间",
        path:shareUrl
      }
    }
  },

// 点击开始游戏事件
async startGame() {
    console.log("开始监听房间ID:", this.data.roomId); // 添加日志打印
    const db = wx.cloud.database();
    const roomId = this.data.roomId; // 从页面数据中获取房间ID
    const selectedCapacity = this.data.selectedCapacity; // 从页面数据中获取房间容量

    // 随机选择车长索引
    //const leaderIndex = Math.floor(Math.random() * selectedCapacity);

    const leaderIndex = 0;

    // 初始化 players 数组
    const players = [];
    for (let i = 0; i < selectedCapacity; i++) {
        players.push({
            isTeamMember: false,
            voted: false,
        });
    }

    try {
        // 调用 assignRoles 分配角色
        const roles = this.assignRoles(); // 获取分配的角色数组

        // 初始化 game 数据
        const gameData = {
            roomId: roomId,
            currentRound: 1,
            currentStage: 1,
            leaderIndex: leaderIndex,
            players: players,
            roles: roles, // 将分配的角色信息加入 gameData
            roomId:roomId,
            roundResults: [{
                round: 1,
                success: false,
                resCount: {
                    success: 0,
                    against: 0,
                },
            }],
            gameStatus: true // 添加游戏状态字段
        };

        // 创建游戏记录
        const res = await db.collection('game').add({
            data: gameData
        });
        console.log("游戏记录创建成功，gameId:", res._id); // 添加日志

        // 跳转至主页面，携带 roomId
        wx.navigateTo({
            url: `/pages/main/main?roomId=${roomId}` // 传递房间ID
        });
    } catch (error) {
        console.error("创建游戏失败：", error);
        // 处理错误，例如弹出提示
        wx.showToast({
            title: '创建游戏失败',
            icon: 'none'
        });
    }
},


assignRoles() {
    const selectedCapacity = this.data.selectedCapacity;
    let roles = [];

    // 根据房间容量分配角色序号
    switch (selectedCapacity) {
        case 5:
            roles = [1, 2, 3, 11, 7]; // 5人局
            break;
        case 6:
            roles = [1, 11, 3, 4, 2, 7]; // 6人局
            break;
        case 7:
            roles = [1, 11, 3, 4, 2, 7, 9]; // 7人局
            break;
        case 8:
            roles = [1, 11, 3, 4, 5, 2, 7, 10]; // 8人局
            break;
        case 9:
            roles = [1, 11, 3, 4, 5, 6, 2, 7, 8]; // 9人局
            break;
        case 10:
            roles = [1, 11, 3, 4, 5, 6, 2, 7, 8, 9]; // 10人局
            break;
        default:
            console.error("无效的房间容量:", selectedCapacity);
            return Promise.reject("无效的房间容量");
    }

    const shuffledRoles = this.shuffleArray(roles); // 随机洗牌角色
    console.log("分配的角色:", shuffledRoles);
    return shuffledRoles;
},

 // 洗牌函数
 shuffleArray(array) {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
    return array;
},


setupGameListener(roomId) {
    console.log("开始监听房间ID:", roomId); // 添加日志打印
    const db = wx.cloud.database();

    // 查询是否存在与当前 roomId 相关的游戏数据
    db.collection('game').where({ roomId: roomId }).get({
        success: (res) => {
            if (res.data.length > 0  && !this.data.hasNavigated ) {
                console.log("找到游戏数据，准备跳转");
                this.stopRoomInfoUpdate(); // 停止信息同步
                // 设置标志位为 true，表示已经跳转 
                this.setData({ 
                    hasNavigated: true 
                  }); 
                wx.navigateTo({
                    url: `/pages/main/main?roomId=${roomId}` // 直接跳转到主页面
                });
            } else {
                console.log("没有找到与此房间ID相关的游戏数据");

                // 如果没有找到，则开始监听数据变化
                db.collection('game').where({ roomId: roomId }).watch({
                    onChange: (snapshot) => {
                        console.log("监听到数据变化:", snapshot); // 打印快照信息
                        if (snapshot.docChanges.length > 0  && !this.data.hasNavigated ) {
                            console.log("检测到游戏数据变更，准备跳转");
                            this.stopRoomInfoUpdate(); // 停止信息同步
                            // 设置标志位为 true，表示已经跳转 
                            this.setData({ 
                                hasNavigated: true 
                            }); 
                            wx.navigateTo({
                                url: `/pages/main/main?roomId=${roomId}` // 直接跳转到主页面
                            });
                        }
                    },
                    onError: (error) => {
                        console.error("监听失败：", error);
                    }
                });
            }
        },
        fail: (err) => {
            console.error("查询失败:", err);
        }
    });
}


});
